package com.yinhe.util.schedule;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yinhe.model.jibeiPO.*;
import com.yinhe.service.jibeiSync.IJiBeiService;
import com.yinhe.util.RedisUtils;
import com.yinhe.util.jibeiSync.DateTimeUtil;
import com.yinhe.util.jibeiSync.redisListJsonUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 定时任务不需要单独引用pom依赖，使用的是springboot自带的
 * 本类为定时任务类，定时任务运行机制为在启动类上使用EnableScheduling注解
 * 在controller层,service层等类中方法使用@Scheduled注解，标注为定时方法
 * @Component 单独放在定时类中，方便管理，此注解将类交给spring维护，可以使用@Autowire导入service层类
 */
@Slf4j
@Component
public class SimScheduleTask {


    @Value("${jibei.filePath}")
    private String filePath;

    @Autowired
    private IJiBeiService iJiBeiService;

    @Autowired
    private RedisUtils redisUtils;

    @Scheduled(cron = "0 0 1 * * ?")
    private void configureTasks(){
        log.info("定期清理7天前的文件夹-定时任务执行--开始");
        try {
            iJiBeiService.deleteDirAndFiles();
            log.info("定期清理7天前的文件夹-定时任务执行--结束");
        } catch (IOException e) {
            log.info("文件定期清理失败："+ e);
        }
    }


    /**
     * 每分钟执行，以便保证每天96刻度值的时候性
     */
    // @Scheduled(cron = "0 0/3 * * * ?")
    // private void configureTasks(){
    //     log.info("96刻度值-定时任务执行");
    //     List<String> today96Point = redisUtils.getList("TODAY96POINT");
    //     // 获取已经生成的96刻度值
    //     if (today96Point==null || today96Point.size()==0){
    //         today96Point = DateTimeUtil.getToday96Point();
    //         redisUtils.setList("TODAY96POINT",today96Point);
    //     }else {
    //         String have96Time = today96Point.get(0);
    //         LocalDate localDate = DateTimeUtil.IsoStringToLocateDate(have96Time).toLocalDate();
    //         LocalDate systemTime = LocalDateTime.now().toLocalDate();
    //         // 两者不相等，从新生成时刻表
    //         if(!localDate.isEqual(systemTime)){
    //             today96Point = DateTimeUtil.getToday96Point();
    //             redisUtils.setList("TODAY96POINT",today96Point);
    //         }
    //     }
    // }


    /**
     * 冀北项目，每10分钟定时一次
     */
    // @Scheduled(cron = "0 0/1 * * * ?")
    private void jibeiTask(){
        // 1、根据当前系统时间获取当天的日期，然后生成96刻度点(比对当前时间是否和96刻度时间一样，不一样，再从新生成)。
        // 2、根据96刻度点，定时获取所有已经存在本地磁盘下的安分的文件，并且将其以当前时刻存放至redis中。
        // 3、hvbi定时根据时间拿值，通过参数，返回给当前参数前的所有数据。

        List<String> today96Point = redisUtils.getList("TODAY96POINT");
        // 获取已经生成的96刻度值
        if (today96Point==null || today96Point.size()==0){

            today96Point = DateTimeUtil.getToday96Point();
            redisUtils.setList("TODAY96POINT",today96Point);
        }else {
            String have96Time = today96Point.get(0);
            LocalDate localDate = DateTimeUtil.IsoStringToLocateDate(have96Time).toLocalDate();
            LocalDate systemTime = LocalDateTime.now().toLocalDate();
            // 两者不相等，从新生成时刻表
            if(!localDate.isEqual(systemTime)){
                today96Point = DateTimeUtil.getToday96Point();
                redisUtils.setList("TODAY96POINT",today96Point);
            }
        }

        //三相单相最大短路电流(单相和三相)
        List<SCCOUT_PO> sccout_poList = new ArrayList<>();
        //新能源多路短路比
        List<DSA_XNY_DLB_UN_PO> dsa_xny_dlb_un_poList = new ArrayList<>();
        // 稳定裕度分析
        List<TTCOutput_PO> ttcOutput_poList = new ArrayList<>();
        // 最大越限百分比
        List<SAOUT_OVER_PO> saoutOverPoList = new ArrayList<>();
        // 电压稳定分析
        List<GD_VSOUT_PO> gd_vsout_poList = new ArrayList<>();
        // 最低阻尼比
        List<SSTOUT_PO> sstout_poList = new ArrayList<>();
        // 最大公交差、最低电压
        List<GD_STOUT_PO> gd_stout_poList = new ArrayList<>();

        // 遍历读取所有刻度文件
        // 根据刻度取读取文件（1、当前系统前的刻度值文件。2、当期系统之前redis不存在的文件刻度值）
        LocalDateTime now = LocalDateTime.now();
        List<String> nowAllPoint = today96Point.stream().filter(s ->  DateTimeUtil.IsoStringToLocateDate(s).isBefore(now)).collect(Collectors.toList());

        log.info("定时器同步解析安分文件开始");
        for (String itemPoint : nowAllPoint) {

            List<SCCOUT_PO> sccout_pos = iJiBeiService.selectPSQSShortCircuitMax("PSASP_STCRIT.QS", "SCCOUT", itemPoint);
            if(sccout_pos!=null&&sccout_pos.size()>0){
                sccout_poList.addAll(sccout_pos);
            }

            List<DSA_XNY_DLB_UN_PO> dsa_xny_dlb_un_pos = iJiBeiService.selectXNY("XNY.res", "DSA_XNY_DLB_UN", itemPoint);
            if(dsa_xny_dlb_un_pos!=null&&dsa_xny_dlb_un_pos.size()>0){
                dsa_xny_dlb_un_poList.addAll(dsa_xny_dlb_un_pos);
            }

            List<TTCOutput_PO> ttcOutputs = iJiBeiService.selectPhase("phase2.res", "TTCOutput", itemPoint);
            if(ttcOutputs!=null&&ttcOutputs.size()>0){
                ttcOutput_poList.addAll(ttcOutputs);
            }

            List<SAOUT_OVER_PO> saoutOverPos = iJiBeiService.selectPSQSOutLimitRate("PSASP_STCRIT.QS", "SAOUT_OVER", itemPoint);
            if(saoutOverPos!=null&&saoutOverPos.size()>0){
                saoutOverPoList.addAll(saoutOverPos);
            }

            List<GD_VSOUT_PO> vsout_pos = iJiBeiService.selectPSQSVoltageStabilityAnaly("PSASP_STCRIT.QS", "GD_VSOUT", itemPoint);
            if(vsout_pos!=null && vsout_pos.size()>0){
                gd_vsout_poList.addAll(vsout_pos);
            }

            List<SSTOUT_PO> sstout_pos = iJiBeiService.selectPSQSDampingMin("PSASP_STCRIT.QS", "SSTOUT", itemPoint);
            if (sstout_pos!=null && sstout_pos.size()>0){
                sstout_poList.addAll(sstout_pos);
            }

            List<GD_STOUT_PO> gd_stout_pos = iJiBeiService.selectPSQSPowerAngleMax("PSASP_STCRIT.QS", "GD_STOUT", itemPoint);
            if (gd_stout_pos!=null && gd_stout_pos.size()>0){
                gd_stout_poList.addAll(gd_stout_pos);
            }

        }

        // 序列化，并存放到redis中
        List<String> sccout_poListstr = null;
        List<String> dsa_xny_dlb_un_poListstr = null;
        List<String> ttcOutput_poListstr = null;
        List<String> saoutOverPoListstr = null;
        List<String> gd_vsout_poListstr = null;
        List<String> sstout_poListstr = null;
        List<String> gd_stout_poListstr = null;
        try {
            sccout_poListstr = redisListJsonUtil.objectTOJson(sccout_poList);
            dsa_xny_dlb_un_poListstr = redisListJsonUtil.objectTOJson(dsa_xny_dlb_un_poList);
            ttcOutput_poListstr = redisListJsonUtil.objectTOJson(ttcOutput_poList);
            saoutOverPoListstr = redisListJsonUtil.objectTOJson(saoutOverPoList);
            gd_vsout_poListstr = redisListJsonUtil.objectTOJson(gd_vsout_poList);
            sstout_poListstr = redisListJsonUtil.objectTOJson(sstout_poList);
            gd_stout_poListstr = redisListJsonUtil.objectTOJson(gd_stout_poList);
        } catch (JsonProcessingException e) {
            log.info("对象转json报错："+ e);
        }
        redisUtils.setList("SCCOUT",sccout_poListstr );
        redisUtils.setList("DSA_XNY_DLB_UN",dsa_xny_dlb_un_poListstr );
        redisUtils.setList("TTCOutput",ttcOutput_poListstr );
        redisUtils.setList("SAOUT_OVER",saoutOverPoListstr );
        redisUtils.setList("GD_VSOUT",gd_vsout_poListstr );
        redisUtils.setList("SSTOUT",sstout_poListstr );
        redisUtils.setList("GD_STOUT",gd_stout_poListstr );
        log.info("定时器同步解析安分文件结束");
    }






}
